import {
    IContext,
    IParam,
    computedNavData,
    deepCopy,
    getSessionStorage,
    IHttpResponse,
} from '@/core';
import { getCookie } from 'qx-util';
import { Ref } from 'vue';

/**
 * 处理编辑器导航参数
 *
 * @export
 * @param {Record<string, any>} props
 * @return {*}
 */
export function handleEditorNavParams(props: Record<string, any>) {
    const { localContext, localParam, data } = props;
    const { context, viewParams } = useContextParams(props);
    const navParams = {
        navContext: context.value,
        navViewParam: viewParams.value,
    };
    if (localContext && Object.keys(localContext).length > 0) {
        const _context = computedNavData(
            data,
            navParams.navContext,
            navParams.navViewParam,
            localContext
        );
        Object.assign(navParams.navContext, _context);
    }
    if (localParam && Object.keys(localParam).length > 0) {
        const _param = computedNavData(
            data,
            navParams.navContext,
            navParams.navViewParam,
            localParam
        );
        Object.assign(navParams.navViewParam, _param);
    }
    return navParams;
}

/**
 * 处理上下文参数
 *
 * @export
 * @param {Record<any, any>} props
 * @return {*}
 */
export function useContextParams(props: Record<any, any>) {
    const { context, viewParams } = props;
    // 维护上下文并监控其变化
    const _context: Ref<IContext> = ref({});
    watch(
        () => context,
        (newVal: any, oldVal: any) => {
            _context.value = deepCopy(newVal || {});
        },
        {
            immediate: true,
            deep: true,
        }
    );
    // 维护视图参数并监控其变化
    const _viewParams: Ref<IParam> = ref({});
    watch(
        () => viewParams,
        (newVal: any, oldVal: any) => {
            _viewParams.value = deepCopy(newVal || {});
        },
        {
            immediate: true,
            deep: true,
        }
    );
    return { context: _context, viewParams: _viewParams };
}

// 获取文件上传路径
export function getUploadUrl(): string {
    const { uploadFileUrl } = App.getProjectSetting();
    return import.meta.env.VITE_BASE_URL + uploadFileUrl;
}

//获取文件下载路径
export function getDownloadUrl(): string {
    const { exportFileUrl } = App.getProjectSetting();
    return import.meta.env.VITE_BASE_URL + exportFileUrl;
}

//获取文件请求头
export function getRequestingHeader(): IParam {
    const headers: IParam = {};
    if (App.getProjectSetting().saasMode) {
        const activeOrgData = getSessionStorage('activeOrgData');
        headers['srforgid'] = activeOrgData?.orgid;
        headers['srfsystemid'] = activeOrgData?.systemid;
    }
    if (getCookie('ibzuaa-token')) {
        headers['Authorization'] = `Bearer ${getCookie('ibzuaa-token')}`;
    } else {
        // 第三方应用打开免登
        if (sessionStorage.getItem('srftoken')) {
            const token = sessionStorage.getItem('srftoken');
            headers['Authorization'] = `Bearer ${token}`;
        }
    }
    return headers;
}

// 编辑器数据类型参数接口
interface IEditorTypeParams {
    valueType?: string;
    valueSeparator?: string;
    textSeparator?: string;
    objectIdField?: string;
    objectNameField?: string;
    objectValueField?: string;
}

// 处理编辑器数据类型相关参数（VALUETYPE/VALUESEPARATOR/TEXTSEPARATOR/OBJECTIDFIELD/OBJECTNAMEFIELD/OBJECTVALUEFIELD）
export function useEditorTypeParams(params: IParam = {}) {
    const editorTypeParams: IEditorTypeParams = {};
    const compAttrs: IParam = useAttrs();
    const editorType = compAttrs.editorType;
    const editorStyle = compAttrs.editorStyle;
    if (compAttrs.VALUETYPE) {
        editorTypeParams.valueType = compAttrs.VALUETYPE;
    }
    if (compAttrs.VALUESEPARATOR) {
        editorTypeParams.valueSeparator = compAttrs.VALUESEPARATOR;
    }
    if (compAttrs.TEXTSEPARATOR) {
        editorTypeParams.textSeparator = compAttrs.TEXTSEPARATOR;
    }
    if (compAttrs.OBJECTIDFIELD) {
        editorTypeParams.objectIdField = compAttrs.OBJECTIDFIELD;
    }
    if (compAttrs.OBJECTNAMEFIELD) {
        editorTypeParams.objectNameField = compAttrs.OBJECTNAMEFIELD;
    }
    if (compAttrs.OBJECTVALUEFIELD) {
        editorTypeParams.objectValueField = compAttrs.OBJECTVALUEFIELD;
    }
    // 校验方法
    const validateConfig = () => {
        let result: boolean = true;
        if (!editorTypeParams.valueType) {
            return result;
        }
        switch (editorType) {
            case 'CHECKBOX': // 选项框
            case 'DATEPICKEREX': // 时间选择器（旧）
            case 'DATEPICKEREX_NOTIME': // 时间选择器（YYYY-MM-DD）
            case 'DATEPICKER': // 时间选择器
            case 'DATEPICKEREX_HOUR': // 时间选择器（YYYY-MM-DD HH）
            case 'DATEPICKEREX_MINUTE': // 时间选择器（YYYY-MM-DD HH:mm）
            case 'DATEPICKEREX_SECOND': // 时间选择器（YYYY-MM-DD HH:mm:ss）
            case 'DATEPICKEREX_NODAY': // 时间选择器（HH:mm:ss）
            case 'DATEPICKEREX_NODAY_NOSECOND': // 时间选择器（HH:mm）
            case 'DATEPICKEREX_NOSECOND': // 时间选择器（YYYY-MM-DD HH:mm）
            case 'TEXTBOX': // 文本框
            case 'NUMBER': // 数值框
            case 'PASSWORD': // 密码框
            case 'TEXTAREA': // 多行输入框
            case 'TEXTAREA_10': // 多行输入框（10行）
            case "HTMLEDITOR": // HTML编辑框
            case "SPAN_COLORSPAN": // 颜色文字
            case "SPAN_AFTERTIME": // 多久之前
            case "SPAN_ADDRESSPICKUP": // 地址栏信息数据
            case "SLIDER_PROGRESS": // 进度条
            case "MAPPICKER": // 地图选择器
            case 'MARKDOWN': // Markdown编辑框
            case 'RADIOBUTTONLIST': // 单选项列表
            case 'RAW': // 直接内容
            case 'RATING': // 评分器
            case 'SPAN': // 标签
            case 'SPAN_TITLE': // 标签扩展样式
            case 'STEPPER': // 步进器
            case 'SWITCH': // 开关部件
            case 'IPADDRESSTEXTBOX': // IP地址输入框
            case 'DROPDOWNLIST': // 下拉列表框
            case 'DROPDOWNLIST_TREESELECT': // 下拉树
            case 'DROPDOWNLIST_CASCADER': // 下拉级联选择
            case 'MDROPDOWNLIST_TREESELECT':// 下拉树选择（多选）
            case 'MDROPDOWNLIST_CASCADER': // 下拉级联选择（多选）
            case 'MDROPDOWNLIST': // 下拉列表框（多选）
            case 'DROPDOWNLIST_100': // 下拉列表框（100宽度）
            case "NUMBERRANGE": // 数值范围编辑框
            case "DATERANGE": // 时间范围选择器
            case "DATERANGE_NOTIME": // 时间范围选择器（YYYY-MM-DD）
            case 'AC': // 自动填充
            case 'AC_FS': // 自动填充（只能选择）
            case 'AC_NOBUTTON': // 自动填充（无按钮）
            case 'AC_FS_NOBUTTON': // 自动填充（只能选择、无按钮）
            case 'CASCADER': // 级联选择 暂不支持
            case 'CASCADER_TREESELECT': // 级联选择树 暂不支持
                // 自定义数据源下拉树
                if (editorStyle == 'TREEDROPDOWNLIST' || editorType == 'DROPDOWNLIST' || editorType == 'MDROPDOWNLIST') {
                    if (!(editorTypeParams.valueType === 'SIMPLE' || editorTypeParams.valueType === 'SIMPLES' || editorTypeParams.valueType === 'OBJECT' || editorTypeParams.valueType === 'OBJECTS')) {
                        console.error(`${editorType}类型编辑器不支持非SIMPLE、SIMPLES、OBJECT、OBJECTS数据类型`);
                        result = false;
                    }
                } else if (editorTypeParams.valueType !== 'SIMPLE') {
                    console.error(`${editorType}类型编辑器不支持非SIMPLE数据类型`);
                    result = false;
                }
                break;
            case "ARRAY": //数组编辑器
                if (editorTypeParams.valueType !== 'SIMPLES') {
                    console.error(`${editorType}类型编辑器不支持非SIMPLES数据类型`);
                    result = false;
                }
                break;
            case 'SLIDER': // 滑动输入条
            case 'CHECKBOXLIST': // 选项框列表
            case 'LISTBOXPICKUP': // 列表框（选择）
            case 'LISTBOX': // 列表框
                if (!(editorTypeParams.valueType === 'SIMPLE' || editorTypeParams.valueType === 'SIMPLES')) {
                    console.error(`${editorType}类型编辑器不支持非SIMPLE、SIMPLES数据类型`);
                    result = false;
                }
                break;
            case "PICTURE_ONE": // 图片控件（单项）
            case "PICTURE_ONE_RAW": // 图片控件（单项、直接内容）
            case 'FILEUPLOADER_ONE': // 文件控件（单项）
            case 'FILEUPLOADER': // 文件控件
            case 'PICTURE': // 图片控件
                if (!(editorTypeParams.valueType === 'SIMPLE' || editorTypeParams.valueType === 'OBJECT' || editorTypeParams.valueType === 'OBJECTS')) {
                    console.error(`${editorType}类型编辑器不支持非SIMPLE、OBJECT、OBJECTS数据类型`);
                    result = false;
                }
                break;
            case "DROPDOWNLIST_TREEDROPDOWNLIST": // 自定义数据源下拉树
            case 'PICKEREX_LINKONLY': // 数据链接
            case "PICKUPVIEW": // 数据选择（嵌入选择视图）
            case "PICKEREX_DROPDOWNVIEW": // 数据选择（下拉视图）
            case "PICKEREX_DROPDOWNVIEW_LINK": // 数据选择（下拉视图、数据链接）
            case "PICKER_ORGSELECT": // 单位选择 暂不支持
            case "PICKER_ORGMULTIPLE":// 单位选择 暂不支持
            case "PICKER_ALLORGSELECT":// 单位选择 暂不支持
            case "PICKER_ALLORGMULTIPLE":// 单位选择 暂不支持
            case "PICKER_ALLDEPATMENTSELECT": // 部门选择 暂不支持
            case "PICKER_ALLDEPATMENTMULTIPLE":// 部门选择 暂不支持
            case "PICKER_DEPATMENTSELECT":// 部门选择 暂不支持
            case "PICKER_DEPATMENTMULTIPLE":// 部门选择 暂不支持
            case "PICKER_ALLDEPTPERSONSELECT": // 人员选择-部门 暂不支持
            case "PICKER_ALLDEPTPERSONMULTIPLE":// 人员选择-部门 暂不支持
            case "PICKER_DEPTPERSONSELECT":// 人员选择-部门 暂不支持
            case "PICKER_DEPTPERSONMULTIPLE":// 人员选择-部门 暂不支持
            case "PICKER_ALLEMPSELECT": // 人员选择- 单位 暂不支持
            case "PICKER_ALLEMPMULTIPLE":// 人员选择- 单位 暂不支持
            case "PICKER_EMPSELECT":// 人员选择- 单位 暂不支持
            case "PICKER_EMPMULTIPLE":// 人员选择- 单位 暂不支持
            case 'PICKER': // 数据选择
            case 'PICKEREX_NOBUTTON': // 数据选择（无按钮）
            case 'PICKEREX_NOAC_LINK': // 数据选择（无AC、数据链接）
            case 'PICKEREX_TRIGGER_LINK':// 数据选择（下拉、数据链接）
            case 'PICKEREX_TRIGGER': // 数据选择（下拉）
            case 'PICKEREX_NOAC': // 数据选择（无AC）
            case 'PICKEREX_LINK': // 数据选择（数据链接）
                if (!(editorTypeParams.valueType === 'SIMPLE' || editorTypeParams.valueType === 'SIMPLES' || editorTypeParams.valueType === 'OBJECT' || editorTypeParams.valueType === 'OBJECTS')) {
                    console.error(`${editorType}类型编辑器不支持非SIMPLE、SIMPLES、OBJECT、OBJECTS数据类型`);
                    result = false;
                }
                break;
            case 'ADDRESSPICKUP': // 地址框（选择）
            case 'ADDRESSPICKUP_AC': // 地址框（支持选择、AC）
                if (!(editorTypeParams.valueType === 'SIMPLE' || editorTypeParams.valueType === 'OBJECTS')) {
                    console.error(`${editorType}类型编辑器不支持非SIMPLE、OBJECTS数据类型`);
                    result = false;
                }
                break;
        }
        return result;
    }
    return {
        ...editorTypeParams,
        validateConfig,
    };
}

/**
 * 处理数据
 *
 * @export
 * @param {Promise<any>} promise
 * @param {string} deKeyField
 * @param {string} deName
 * @param {string} [textCodeName]
 * @param {string} [keyCodeName]
 * @return {*}  {Promise<IParam[]>}
 */
export function handleItems(
    promise: Promise<any>,
    deKeyField: string,
    deName: string,
    textCodeName?: string,
    keyCodeName?: string
): Promise<IParam[]> {
    return new Promise((resolve, reject) => {
        promise
            .then((response: IHttpResponse) => {
                if (response.success) {
                    const data = response.data;
                    data.forEach((item: any, index: number) => {
                        item[deName] = item[deKeyField];
                        if (textCodeName) {
                            item.label = item[textCodeName];
                        }
                        if (keyCodeName) {
                            item.value = item[keyCodeName];
                        }
                        data[index] = item;
                    });
                    resolve(data);
                } else {
                    reject([]);
                }
            })
            .catch((response: any) => {
                reject([]);
            });
    });
}
/**
 * 搜索实体数据集合
 *
 * @export
 * @param {string} serviceName 服务名称
 * @param {string} interfaceName 接口名称
 * @param {*} [context={}] 上下文
 * @param {*} data 参数
 * @param {string} [deKeyField] 应用实体主信息属性名称
 * @param {string} [deName] 应用实体主键属性名称
 * @return {*} {Promise<IParam[]>}
 */
export function searchEntityData(
    serviceName: string,
    interfaceName: string,
    context: any = {},
    data: any,
    deKeyField?: string,
    deName?: string
): Promise<IParam[]> {
    data.page = data.page ? data.page : 0;
    data.size = data.size ? data.size : 1000;
    return new Promise((resolve: any, reject: any) => {
        App.getDataService(serviceName, context)
            .then(async (dataService: any) => {
                if (dataService && dataService[interfaceName] instanceof Function) {
                    const response = await handleItems(
                        dataService[interfaceName](context, data),
                        `${deKeyField}`,
                        `${deName}`,
                        dataService.appEntityTextCodeName,
                        dataService.appEntityKeyCodeName
                    );
                    resolve(response);
                } else {
                    reject([]);
                }
            })
            .catch((error: any) => {
                reject([]);
            });
    });
}